/**
 *
 * @Author 董熠涛
 * @Date 2025/6/16 20:22
 */
package example.springboot.service;

import example.springboot.dto.LoginRequest;
import example.springboot.dto.LoginResponse;
import example.springboot.dto.PageRequest;
import example.springboot.dto.PageResult;
import example.springboot.dto.UserDTO;
import example.springboot.entity.User;
import example.springboot.mapper.UserMapper;
import example.springboot.util.JwtUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private PasswordEncoder passwordEncoder;

    /**
     * 用户登录（通用，不检查角色）
     */
    public LoginResponse login(LoginRequest loginRequest) {
        return login(loginRequest, false);
    }

    /**
     * 用户登录（可指定是否检查管理员角色）
     * @param loginRequest 登录请求
     * @param requireAdmin 是否要求管理员角色
     */
    public LoginResponse login(LoginRequest loginRequest, boolean requireAdmin) {
        // 查询用户
        User user = userMapper.findByUsername(loginRequest.getUsername());
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        // 验证密码
        if (!passwordEncoder.matches(loginRequest.getPassword(), user.getPassword())) {
            throw new RuntimeException("密码错误");
        }

        // 检查账号状态
        if ("banned".equals(user.getStatus())) {
            throw new RuntimeException("账号已被封禁，请联系管理员");
        }

        // 如果要求管理员角色，则验证
        if (requireAdmin) {
            if (user.getRole() == null || !"admin".equals(user.getRole())) {
                throw new RuntimeException("权限不足，只有管理员可以登录管理后台");
            }
        }

        // 生成Token
        String token = jwtUtil.generateToken(user.getId(), user.getUsername());

        // 构建用户信息（不返回密码）
        LoginResponse.UserInfo userInfo = new LoginResponse.UserInfo(
                user.getId(),
                user.getUsername(),
                user.getNickname(),
                user.getEmail(),
                user.getAvatarUrl(),
                user.getRole(),
                user.getStatus()
        );

        return new LoginResponse(token, userInfo);
    }

    /**
     * 根据用户名查询用户
     */
    public User findByUsername(String username) {
        return userMapper.findByUsername(username);
    }

    /**
     * 根据ID查询用户
     */
    public User findById(Integer id) {
        return userMapper.findById(id);
    }

    /**
     * 注册新用户
     */
    public User register(User user) {
        // 检查用户名是否存在
        User existUser = userMapper.findByUsername(user.getUsername());
        if (existUser != null) {
            throw new RuntimeException("用户名已存在");
        }

        // 检查邮箱是否已存在
        if (user.getEmail() != null && !user.getEmail().isEmpty()) {
            User emailExist = userMapper.findByEmail(user.getEmail());
            if (emailExist != null) {
                throw new RuntimeException("邮箱已被使用");
            }
        }

        // 密码加密
        user.setPassword(passwordEncoder.encode(user.getPassword()));

        // 设置默认角色和状态
        if (user.getRole() == null || user.getRole().isEmpty()) {
            user.setRole("user");  // 默认为普通用户
        }
        if (user.getStatus() == null || user.getStatus().isEmpty()) {
            user.setStatus("active");  // 默认为正常状态
        }

        // 插入用户
        userMapper.insert(user);
        return user;
    }

    /**
     * 更新用户信息
     */
    public boolean updateUser(User user) {
        return userMapper.update(user) > 0;
    }

    /**
     * 删除用户
     */
    public boolean deleteUser(Integer id) {
        return userMapper.deleteById(id) > 0;
    }

    /**
     * 分页查询用户列表
     */
    public PageResult<UserDTO> getUserList(PageRequest pageRequest) {
        Integer offset = (pageRequest.getPage() - 1) * pageRequest.getSize();
        List<User> users = userMapper.findByPage(offset, pageRequest.getSize(), pageRequest.getSearch());
        Long total = userMapper.countUsers(pageRequest.getSearch());

        // 转换为DTO，不返回密码
        List<UserDTO> userDTOs = users.stream().map(user -> {
            UserDTO dto = new UserDTO();
            BeanUtils.copyProperties(user, dto);
            return dto;
        }).collect(Collectors.toList());

        return new PageResult<>(userDTOs, total);
    }

    /**
     * 创建用户
     */
    public User createUser(User user) {
        // 检查用户名是否存在
        User existUser = userMapper.findByUsername(user.getUsername());
        if (existUser != null) {
            throw new RuntimeException("用户名已存在");
        }

        // 密码加密
        if (user.getPassword() != null && !user.getPassword().isEmpty()) {
            user.setPassword(passwordEncoder.encode(user.getPassword()));
        }

        // 插入用户
        userMapper.insert(user);
        return user;
    }

    /**
     * 更新用户（管理端）
     */
    public boolean updateUserInfo(User user) {
        User existUser = userMapper.findById(user.getId());
        if (existUser == null) {
            throw new RuntimeException("用户不存在");
        }

        // 只更新允许修改的字段
        existUser.setNickname(user.getNickname());
        existUser.setEmail(user.getEmail());
        
        return userMapper.update(existUser) > 0;
    }
}

